/**
  ******************************************************************************
  * @file    usbd_req.c
  * @author  MCD Application Team
  * @version V1.2.0
  * @date    09-November-2015
  * @brief   This file provides the standard USB requests following chapter 9.
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; COPYRIGHT 2015 STMicroelectronics</center></h2>
  *
  * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License");
  * You may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
  *
  *        http://www.st.com/software_license_agreement_liberty_v2
  *
  * Unless required by applicable law or agreed to in writing, software 
  * distributed under the License is distributed on an "AS IS" BASIS, 
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
  ******************************************************************************
  */

/* Includes ------------------------------------------------------------------*/
#include "usbd_req.h"
#include "usbd_ioreq.h"
#include "usbd_desc.h"


/** @addtogroup STM32_USB_OTG_DEVICE_LIBRARY
  * @{
  */


/** @defgroup USBD_REQ 
  * @brief USB standard requests module
  * @{
  */

/** @defgroup USBD_REQ_Private_TypesDefinitions
  * @{
  */
/**
  * @}
  */


/** @defgroup USBD_REQ_Private_Defines
  * @{
  */

/**
  * @}
  */


/** @defgroup USBD_REQ_Private_Macros
  * @{
  */
/**
  * @}
  */


/** @defgroup USBD_REQ_Private_Variables
  * @{
  */
extern __IO USB_OTG_DCTL_TypeDef SET_TEST_MODE;

#ifdef USB_OTG_HS_INTERNAL_DMA_ENABLED
#if defined(__ICCARM__) /*!< IAR Compiler */
#pragma data_alignment = 4
#endif
#endif /* USB_OTG_HS_INTERNAL_DMA_ENABLED */
__ALIGN_BEGIN uint32_t USBD_ep_status __ALIGN_END = 0;

#ifdef USB_OTG_HS_INTERNAL_DMA_ENABLED
#if defined(__ICCARM__) /*!< IAR Compiler */
#pragma data_alignment = 4
#endif
#endif /* USB_OTG_HS_INTERNAL_DMA_ENABLED */
__ALIGN_BEGIN uint32_t USBD_default_cfg __ALIGN_END = 0;

#ifdef USB_OTG_HS_INTERNAL_DMA_ENABLED
#if defined(__ICCARM__) /*!< IAR Compiler */
#pragma data_alignment = 4
#endif
#endif /* USB_OTG_HS_INTERNAL_DMA_ENABLED */
__ALIGN_BEGIN uint32_t USBD_cfg_status __ALIGN_END = 0;

/**
  * @}
  */


/** @defgroup USBD_REQ_Private_FunctionPrototypes
  * @{
  */
static void USBD_GetDescriptor(USB_OTG_CORE_HANDLE *pdev,
                               USB_SETUP_REQ       *req);

static void USBD_SetAddress(USB_OTG_CORE_HANDLE *pdev,
                            USB_SETUP_REQ       *req);

static void USBD_SetConfig(USB_OTG_CORE_HANDLE *pdev,
                           USB_SETUP_REQ       *req);

static void USBD_GetConfig(USB_OTG_CORE_HANDLE *pdev,
                           USB_SETUP_REQ       *req);

static void USBD_GetStatus(USB_OTG_CORE_HANDLE *pdev,
                           USB_SETUP_REQ       *req);

static void USBD_SetFeature(USB_OTG_CORE_HANDLE *pdev,
                            USB_SETUP_REQ       *req);

static void USBD_ClrFeature(USB_OTG_CORE_HANDLE *pdev,
                            USB_SETUP_REQ       *req);

static uint8_t USBD_GetLen(uint8_t *buf);
/**
  * @}
  */


/** @defgroup USBD_REQ_Private_Functions
  * @{
  */


/**
* @brief  USBD_StdDevReq
*         Handle standard usb device requests
* @param  pdev: device instance
* @param  req: usb request
* @retval status
*/
USBD_Status USBD_StdDevReq(USB_OTG_CORE_HANDLE *pdev, USB_SETUP_REQ *req)
{
    USBD_Status ret = USBD_OK;

    switch (req->bRequest)
    {
    case USB_REQ_GET_DESCRIPTOR:

        USBD_GetDescriptor(pdev, req);
        break;

    case USB_REQ_SET_ADDRESS:
        USBD_SetAddress(pdev, req);
        break;

    case USB_REQ_SET_CONFIGURATION:
        USBD_SetConfig(pdev, req);
        break;

    case USB_REQ_GET_CONFIGURATION:
        USBD_GetConfig(pdev, req);
        break;

    case USB_REQ_GET_STATUS:
        USBD_GetStatus(pdev, req);
        break;


    case USB_REQ_SET_FEATURE:
        USBD_SetFeature(pdev, req);
        break;

    case USB_REQ_CLEAR_FEATURE:
        USBD_ClrFeature(pdev, req);
        break;

    default:
        USBD_CtlError(pdev, req);
        break;
    }

    return ret;
}

/**
* @brief  USBD_StdItfReq
*         Handle standard usb interface requests
* @param  pdev: USB OTG device instance
* @param  req: usb request
* @retval status
*/
USBD_Status USBD_StdItfReq(USB_OTG_CORE_HANDLE *pdev, USB_SETUP_REQ *req)
{
    USBD_Status ret = USBD_OK;

    switch (pdev->dev.device_status)
    {
    case USB_OTG_CONFIGURED:

        if (LOBYTE(req->wIndex) <= USBD_ITF_MAX_NUM)
        {
            pdev->dev.class_cb->Setup(pdev, req);

            if ((req->wLength == 0) && (ret == USBD_OK))
            {
                USBD_CtlSendStatus(pdev);
            }
        }
        else
        {
            USBD_CtlError(pdev, req);
        }
        break;

    default:
        USBD_CtlError(pdev, req);
        break;
    }
    return ret;
}

/**
* @brief  USBD_StdEPReq
*         Handle standard usb endpoint requests
* @param  pdev: USB OTG device instance
* @param  req: usb request
* @retval status
*/
USBD_Status USBD_StdEPReq(USB_OTG_CORE_HANDLE *pdev, USB_SETUP_REQ *req)
{
    uint8_t     ep_addr;
    USBD_Status ret = USBD_OK;

    ep_addr = LOBYTE(req->wIndex);

    /* Check the class specific requests before going to standard request */
    if ((req->bmRequest & USB_REQ_TYPE_MASK) == USB_REQ_TYPE_CLASS)
    {
        pdev->dev.class_cb->Setup(pdev, req);
        return ret;
    }

    switch (req->bRequest)
    {
    case USB_REQ_SET_FEATURE:

        switch (pdev->dev.device_status)
        {
        case USB_OTG_ADDRESSED:
            if ((ep_addr != 0x00) && (ep_addr != 0x80))
            {
                DCD_EP_Stall(pdev, ep_addr);
            }
            break;

        case USB_OTG_CONFIGURED:
            if (req->wValue == USB_FEATURE_EP_HALT)
            {
                if ((ep_addr != 0x00) && (ep_addr != 0x80))
                {
                    DCD_EP_Stall(pdev, ep_addr);
                }
            }
            pdev->dev.class_cb->Setup(pdev, req);
            USBD_CtlSendStatus(pdev);

            break;

        default:
            USBD_CtlError(pdev, req);
            break;
        }
        break;

    case USB_REQ_CLEAR_FEATURE:

        switch (pdev->dev.device_status)
        {
        case USB_OTG_ADDRESSED:
            if ((ep_addr != 0x00) && (ep_addr != 0x80))
            {
                DCD_EP_Stall(pdev, ep_addr);
            }
            break;

        case USB_OTG_CONFIGURED:
            if (req->wValue == USB_FEATURE_EP_HALT)
            {
                if ((ep_addr != 0x00) && (ep_addr != 0x80))
                {
                    DCD_EP_ClrStall(pdev, ep_addr);
                    pdev->dev.class_cb->Setup(pdev, req);
                }
                USBD_CtlSendStatus(pdev);
            }
            break;

        default:
            USBD_CtlError(pdev, req);
            break;
        }
        break;

    case USB_REQ_GET_STATUS:
        switch (pdev->dev.device_status)
        {
        case USB_OTG_ADDRESSED:
            if ((ep_addr != 0x00) && (ep_addr != 0x80))
            {
                DCD_EP_Stall(pdev, ep_addr);
            }
            break;

        case USB_OTG_CONFIGURED:


            if ((ep_addr & 0x80) == 0x80)
            {
                if (pdev->dev.in_ep[ep_addr & 0x7F].is_stall)
                {
                    USBD_ep_status = 0x0001;
                }
                else
                {
                    USBD_ep_status = 0x0000;
                }
            }
            else if ((ep_addr & 0x80) == 0x00)
            {
                if (pdev->dev.out_ep[ep_addr].is_stall)
                {
                    USBD_ep_status = 0x0001;
                }

                else
                {
                    USBD_ep_status = 0x0000;
                }
            }

            else
            {
                /* Do Nothing */
            }

            USBD_CtlSendData(pdev,
                             (uint8_t *)&USBD_ep_status,
                             2);
            break;

        default:
            USBD_CtlError(pdev, req);
            break;
        }
        break;

    default:
        break;
    }
    return ret;
}
/**
* @brief  USBD_GetDescriptor
*         Handle Get Descriptor requests
* @param  pdev: device instance
* @param  req: usb request
* @retval status
*/
static void USBD_GetDescriptor(USB_OTG_CORE_HANDLE *pdev,
                               USB_SETUP_REQ       *req)
{
    uint16_t len;
    uint8_t *pbuf;
    len = req->wLength;

    switch (req->wValue >> 8)
    {
#if (USBD_LPM_ENABLED == 1)
    case USB_DESC_TYPE_BOS:
        pbuf = pdev->pDesc->GetBOSDescriptor(pdev->dev_speed, &len);
        break;
#endif
    case USB_DESC_TYPE_DEVICE:
        pbuf = pdev->dev.usr_device->GetDeviceDescriptor(pdev->cfg.speed, &len);
        break;

    case USB_DESC_TYPE_CONFIGURATION:
        pbuf = (uint8_t *)pdev->dev.class_cb->GetConfigDescriptor(pdev->cfg.speed, &len);
#ifdef USB_OTG_HS_CORE
        if ((pdev->cfg.speed == USB_OTG_SPEED_FULL) && (pdev->cfg.phy_itface == USB_OTG_ULPI_PHY))
        {
            pbuf = (uint8_t *)pdev->dev.class_cb->GetOtherConfigDescriptor(pdev->cfg.speed, &len);
        }
#endif
        pbuf[1]                      = USB_DESC_TYPE_CONFIGURATION;
        pdev->dev.pConfig_descriptor = pbuf;
        break;

    case USB_DESC_TYPE_STRING:
        switch ((uint8_t)(req->wValue))
        {
        case USBD_IDX_LANGID_STR:
            pbuf = pdev->dev.usr_device->GetLangIDStrDescriptor(pdev->cfg.speed, &len);
            break;

        case USBD_IDX_MFC_STR:
            pbuf = pdev->dev.usr_device->GetManufacturerStrDescriptor(pdev->cfg.speed, &len);
            break;

        case USBD_IDX_PRODUCT_STR:
            pbuf = pdev->dev.usr_device->GetProductStrDescriptor(pdev->cfg.speed, &len);
            break;

        case USBD_IDX_SERIAL_STR:
            pbuf = pdev->dev.usr_device->GetSerialStrDescriptor(pdev->cfg.speed, &len);
            break;

        case USBD_IDX_CONFIG_STR:
            pbuf = pdev->dev.usr_device->GetConfigurationStrDescriptor(pdev->cfg.speed, &len);
            break;

        case USBD_IDX_INTERFACE_STR:
            pbuf = pdev->dev.usr_device->GetInterfaceStrDescriptor(pdev->cfg.speed, &len);
            break;

        default:
#ifdef USB_SUPPORT_USER_STRING_DESC
            pbuf = pdev->dev.class_cb->GetUsrStrDescriptor(pdev->cfg.speed, (req->wValue), &len);
            break;
#else
            USBD_CtlError(pdev, req);
            return;
#endif /* USBD_CtlError(pdev , req)*/
        }
        break;
    case USB_DESC_TYPE_DEVICE_QUALIFIER:
#ifdef USB_OTG_HS_CORE
        if (pdev->cfg.speed == USB_OTG_SPEED_HIGH)
        {
            pbuf = (uint8_t *)pdev->dev.class_cb->GetConfigDescriptor(pdev->cfg.speed, &len);

            USBD_DeviceQualifierDesc[4] = pbuf[14];
            USBD_DeviceQualifierDesc[5] = pbuf[15];
            USBD_DeviceQualifierDesc[6] = pbuf[16];

            pbuf = USBD_DeviceQualifierDesc;
            len  = USB_LEN_DEV_QUALIFIER_DESC;
            break;
        }
        else
        {
            USBD_CtlError(pdev, req);
            return;
        }
#else
        USBD_CtlError(pdev, req);
        return;
#endif

    case USB_DESC_TYPE_OTHER_SPEED_CONFIGURATION:
#ifdef USB_OTG_HS_CORE

        if (pdev->cfg.speed == USB_OTG_SPEED_HIGH)
        {
            pbuf    = (uint8_t *)pdev->dev.class_cb->GetOtherConfigDescriptor(pdev->cfg.speed, &len);
            pbuf[1] = USB_DESC_TYPE_OTHER_SPEED_CONFIGURATION;
            break;
        }
        else
        {
            USBD_CtlError(pdev, req);
            return;
        }
#else
        USBD_CtlError(pdev, req);
        return;
#endif
    default:
        USBD_CtlError(pdev, req);
        return;
    }

    if ((len != 0) && (req->wLength != 0))
    {
        len = MIN(len, req->wLength);

        USBD_CtlSendData(pdev,
                         pbuf,
                         len);
    }
}

/**
* @brief  USBD_SetAddress
*         Set device address
* @param  pdev: device instance
* @param  req: usb request
* @retval status
*/
static void USBD_SetAddress(USB_OTG_CORE_HANDLE *pdev,
                            USB_SETUP_REQ       *req)
{
    uint8_t dev_addr;

    if ((req->wIndex == 0) && (req->wLength == 0))
    {
        dev_addr = (uint8_t)(req->wValue) & 0x7F;

        if (pdev->dev.device_status == USB_OTG_CONFIGURED)
        {
            USBD_CtlError(pdev, req);
        }
        else
        {
            pdev->dev.device_address = dev_addr;
            DCD_EP_SetAddress(pdev, dev_addr);
            USBD_CtlSendStatus(pdev);

            if (dev_addr != 0)
            {
                pdev->dev.device_status = USB_OTG_ADDRESSED;
            }
            else
            {
                pdev->dev.device_status = USB_OTG_DEFAULT;
            }
        }
    }
    else
    {
        USBD_CtlError(pdev, req);
    }
}

/**
* @brief  USBD_SetConfig
*         Handle Set device configuration request
* @param  pdev: device instance
* @param  req: usb request
* @retval status
*/
static void USBD_SetConfig(USB_OTG_CORE_HANDLE *pdev,
                           USB_SETUP_REQ       *req)
{
    static uint8_t cfgidx;

    cfgidx = (uint8_t)(req->wValue);

    if (cfgidx > USBD_CFG_MAX_NUM)
    {
        USBD_CtlError(pdev, req);
    }
    else
    {
        switch (pdev->dev.device_status)
        {
        case USB_OTG_ADDRESSED:
            if (cfgidx)
            {
                pdev->dev.device_config = cfgidx;
                pdev->dev.device_status = USB_OTG_CONFIGURED;
                USBD_SetCfg(pdev, cfgidx);
                USBD_CtlSendStatus(pdev);
            }
            else
            {
                USBD_CtlSendStatus(pdev);
            }
            break;

        case USB_OTG_CONFIGURED:
            if (cfgidx == 0)
            {
                pdev->dev.device_status = USB_OTG_ADDRESSED;
                pdev->dev.device_config = cfgidx;
                USBD_ClrCfg(pdev, cfgidx);
                USBD_CtlSendStatus(pdev);
            }
            else if (cfgidx != pdev->dev.device_config)
            {
                /* Clear old configuration */
                USBD_ClrCfg(pdev, pdev->dev.device_config);

                /* set new configuration */
                pdev->dev.device_config = cfgidx;
                USBD_SetCfg(pdev, cfgidx);
                USBD_CtlSendStatus(pdev);
            }
            else
            {
                USBD_CtlSendStatus(pdev);
            }
            break;

        default:
            USBD_CtlError(pdev, req);
            break;
        }
    }
}

/**
* @brief  USBD_GetConfig
*         Handle Get device configuration request
* @param  pdev: device instance
* @param  req: usb request
* @retval status
*/
static void USBD_GetConfig(USB_OTG_CORE_HANDLE *pdev,
                           USB_SETUP_REQ       *req)
{
    if (req->wLength != 1)
    {
        USBD_CtlError(pdev, req);
    }
    else
    {
        switch (pdev->dev.device_status)
        {
        case USB_OTG_ADDRESSED:

            USBD_CtlSendData(pdev,
                             (uint8_t *)&USBD_default_cfg,
                             1);
            break;

        case USB_OTG_CONFIGURED:

            USBD_CtlSendData(pdev,
                             &pdev->dev.device_config,
                             1);
            break;

        default:
            USBD_CtlError(pdev, req);
            break;
        }
    }
}

/**
* @brief  USBD_GetStatus
*         Handle Get Status request
* @param  pdev: device instance
* @param  req: usb request
* @retval status
*/
static void USBD_GetStatus(USB_OTG_CORE_HANDLE *pdev,
                           USB_SETUP_REQ       *req)
{
    switch (pdev->dev.device_status)
    {
    case USB_OTG_ADDRESSED:
    case USB_OTG_CONFIGURED:

#ifdef USBD_SELF_POWERED
        USBD_cfg_status = USB_CONFIG_SELF_POWERED;
#else
        USBD_cfg_status = 0x00;
#endif

        if (pdev->dev.DevRemoteWakeup)
        {
            USBD_cfg_status |= USB_CONFIG_REMOTE_WAKEUP;
        }

        USBD_CtlSendData(pdev,
                         (uint8_t *)&USBD_cfg_status,
                         2);
        break;

    default:
        USBD_CtlError(pdev, req);
        break;
    }
}


/**
* @brief  USBD_SetFeature
*         Handle Set device feature request
* @param  pdev: device instance
* @param  req: usb request
* @retval status
*/
static void USBD_SetFeature(USB_OTG_CORE_HANDLE *pdev,
                            USB_SETUP_REQ       *req)
{
    USB_OTG_DCTL_TypeDef dctl;
    uint8_t              test_mode = 0;

    if (req->wValue == USB_FEATURE_REMOTE_WAKEUP)
    {
        pdev->dev.DevRemoteWakeup = 1;
        pdev->dev.class_cb->Setup(pdev, req);
        USBD_CtlSendStatus(pdev);
    }

    else if ((req->wValue == USB_FEATURE_TEST_MODE) && ((req->wIndex & 0xFF) == 0))
    {
        dctl.d32 = USB_OTG_READ_REG32(&pdev->regs.DREGS->DCTL);

        test_mode = req->wIndex >> 8;
        switch (test_mode)
        {
        case 1: /* TEST_J */
            dctl.b.tstctl = 1;
            break;

        case 2: /* TEST_K */
            dctl.b.tstctl = 2;
            break;

        case 3: /* TEST_SE0_NAK */
            dctl.b.tstctl = 3;
            break;

        case 4: /* TEST_PACKET */
            dctl.b.tstctl = 4;
            break;

        case 5: /* TEST_FORCE_ENABLE */
            dctl.b.tstctl = 5;
            break;

        default:
            dctl.b.tstctl = 1;
            break;
        }
        SET_TEST_MODE       = dctl;
        pdev->dev.test_mode = 1;
        USBD_CtlSendStatus(pdev);
    }
    else
    {
        /* Do Nothing */
    }
}


/**
* @brief  USBD_ClrFeature
*         Handle clear device feature request
* @param  pdev: device instance
* @param  req: usb request
* @retval status
*/
static void USBD_ClrFeature(USB_OTG_CORE_HANDLE *pdev,
                            USB_SETUP_REQ       *req)
{
    switch (pdev->dev.device_status)
    {
    case USB_OTG_ADDRESSED:
    case USB_OTG_CONFIGURED:
        if (req->wValue == USB_FEATURE_REMOTE_WAKEUP)
        {
            pdev->dev.DevRemoteWakeup = 0;
            pdev->dev.class_cb->Setup(pdev, req);
            USBD_CtlSendStatus(pdev);
        }
        break;

    default:
        USBD_CtlError(pdev, req);
        break;
    }
}

/**
* @brief  USBD_ParseSetupRequest 
*         Copy buffer into setup structure
* @param  pdev: device instance
* @param  req: usb request
* @retval None
*/

void USBD_ParseSetupRequest(USB_OTG_CORE_HANDLE *pdev,
                            USB_SETUP_REQ       *req)
{
    req->bmRequest = *(uint8_t *)(pdev->dev.setup_packet);
    req->bRequest  = *(uint8_t *)(pdev->dev.setup_packet + 1);
    req->wValue    = SWAPBYTE(pdev->dev.setup_packet + 2);
    req->wIndex    = SWAPBYTE(pdev->dev.setup_packet + 4);
    req->wLength   = SWAPBYTE(pdev->dev.setup_packet + 6);

    pdev->dev.in_ep[0].ctl_data_len = req->wLength;
    pdev->dev.device_state          = USB_OTG_EP0_SETUP;
}

/**
* @brief  USBD_CtlError 
*         Handle USB low level Error
* @param  pdev: device instance
* @param  req: usb request
* @retval None
*/

void USBD_CtlError(USB_OTG_CORE_HANDLE *pdev,
                   USB_SETUP_REQ       *req)
{
    DCD_EP_Stall(pdev, 0x80);
    DCD_EP_Stall(pdev, 0);
    USB_OTG_EP0_OutStart(pdev);
}


/**
  * @brief  USBD_GetString
  *         Convert Ascii string into unicode one
  * @param  desc : descriptor buffer
  * @param  unicode : Formatted string buffer (unicode)
  * @param  len : descriptor length
  * @retval None
  */
void USBD_GetString(uint8_t *desc, uint8_t *unicode, uint16_t *len)
{
    uint8_t idx = 0;

    if (desc != NULL)
    {
        *len           = USBD_GetLen(desc) * 2 + 2;
        unicode[idx++] = *len;
        unicode[idx++] = USB_DESC_TYPE_STRING;

        while (*desc != NULL)
        {
            unicode[idx++] = *desc++;
            unicode[idx++] = 0x00;
        }
    }
}

/**
  * @brief  USBD_GetLen
  *         return the string length
   * @param  buf : pointer to the ascii string buffer
  * @retval string length
  */
static uint8_t USBD_GetLen(uint8_t *buf)
{
    uint8_t len = 0;

    while (*buf != NULL)
    {
        len++;
        buf++;
    }

    return len;
}
/**
  * @}
  */


/**
  * @}
  */


/**
  * @}
  */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
